/*
** Lua binding: CsbufParser
** Generated automatically by tolua++-1.0.92 on 01/04/16 16:29:22.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_CsbufParser_open (lua_State* tolua_S);

#include "lua_csbuf_auto.hpp"
#include "CsbufParser.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_CsbufParser (lua_State* tolua_S)
{
 CsbufParser* self = (CsbufParser*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"size_t");
 tolua_usertype(tolua_S,"CsbufParser");
}

/* method: new of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_new00
static int tolua_CsbufParser_CsbufParser_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CsbufParser* tolua_ret = (CsbufParser*)  Mtolua_new((CsbufParser)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CsbufParser");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_new00_local
static int tolua_CsbufParser_CsbufParser_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CsbufParser* tolua_ret = (CsbufParser*)  Mtolua_new((CsbufParser)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CsbufParser");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_new01
static int tolua_CsbufParser_CsbufParser_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const CsbufParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const CsbufParser* buf = ((const CsbufParser*)  tolua_tousertype(tolua_S,2,0));
  {
   CsbufParser* tolua_ret = (CsbufParser*)  Mtolua_new((CsbufParser)(*buf));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CsbufParser");
  }
 }
 return 1;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_new01_local
static int tolua_CsbufParser_CsbufParser_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const CsbufParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const CsbufParser* buf = ((const CsbufParser*)  tolua_tousertype(tolua_S,2,0));
  {
   CsbufParser* tolua_ret = (CsbufParser*)  Mtolua_new((CsbufParser)(*buf));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CsbufParser");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_delete00
static int tolua_CsbufParser_CsbufParser_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setData of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setData00
static int tolua_CsbufParser_CsbufParser_setData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const CsbufParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const CsbufParser* buf = ((const CsbufParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setData'", NULL);
#endif
  {
   self->setData(*buf);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setData of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setData01
static int tolua_CsbufParser_CsbufParser_setData01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const std::string data = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setData'", NULL);
#endif
  {
   self->setData(data);
   tolua_pushcppstring(tolua_S,(const char*)data);
  }
 }
 return 1;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_setData00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setData of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setData02
static int tolua_CsbufParser_CsbufParser_setData02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const char* data = ((const char*)  tolua_tostring(tolua_S,2,0));
  unsigned int len = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setData'", NULL);
#endif
  {
   self->setData(data,len);
  }
 }
 return 0;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_setData01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getData of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getData00
static int tolua_CsbufParser_CsbufParser_getData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getData'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getData();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_clear00
static int tolua_CsbufParser_CsbufParser_clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBool of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setBool00
static int tolua_CsbufParser_CsbufParser_setBool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  bool d = ((bool)  tolua_toboolean(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBool'", NULL);
#endif
  {
   self->setBool(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUint8 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setUint800
static int tolua_CsbufParser_CsbufParser_setUint800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char d = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUint8'", NULL);
#endif
  {
   self->setUint8(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUint8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUint16 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setUint1600
static int tolua_CsbufParser_CsbufParser_setUint1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned short d = (( unsigned short)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUint16'", NULL);
#endif
  {
   self->setUint16(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUint16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUint32 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setUint3200
static int tolua_CsbufParser_CsbufParser_setUint3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned int d = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUint32'", NULL);
#endif
  {
   self->setUint32(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUint32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUint64 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setUint6400
static int tolua_CsbufParser_CsbufParser_setUint6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned long long d = (( unsigned long long)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUint64'", NULL);
#endif
  {
   self->setUint64(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUint64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInt8 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setInt800
static int tolua_CsbufParser_CsbufParser_setInt800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
   char d = ((  char)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInt8'", NULL);
#endif
  {
   self->setInt8(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInt8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInt16 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setInt1600
static int tolua_CsbufParser_CsbufParser_setInt1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
   short d = ((  short)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInt16'", NULL);
#endif
  {
   self->setInt16(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInt16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInt32 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setInt3200
static int tolua_CsbufParser_CsbufParser_setInt3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
   int d = ((  int)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInt32'", NULL);
#endif
  {
   self->setInt32(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInt32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInt64 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setInt6400
static int tolua_CsbufParser_CsbufParser_setInt6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  long long d = (( long long)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInt64'", NULL);
#endif
  {
   self->setInt64(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInt64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFloat of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setFloat00
static int tolua_CsbufParser_CsbufParser_setFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  float d = ((float)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFloat'", NULL);
#endif
  {
   self->setFloat(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDouble of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setDouble00
static int tolua_CsbufParser_CsbufParser_setDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  double d = ((double)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDouble'", NULL);
#endif
  {
   self->setDouble(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setString of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setString00
static int tolua_CsbufParser_CsbufParser_setString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const char* d = ((const char*)  tolua_tostring(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setString'", NULL);
#endif
  {
   self->setString(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setString of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setString01
static int tolua_CsbufParser_CsbufParser_setString01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"size_t",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const char* d = ((const char*)  tolua_tostring(tolua_S,2,0));
  size_t n = *((size_t*)  tolua_tousertype(tolua_S,3,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setString'", NULL);
#endif
  {
   self->setString(d,n,pos);
  }
 }
 return 0;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_setString00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setString of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setString02
static int tolua_CsbufParser_CsbufParser_setString02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  const std::string d = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setString'", NULL);
#endif
  {
   self->setString(d,pos);
   tolua_pushcppstring(tolua_S,(const char*)d);
  }
 }
 return 1;
tolua_lerror:
 return tolua_CsbufParser_CsbufParser_setString01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArray of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setArray00
static int tolua_CsbufParser_CsbufParser_setArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char d = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArray'", NULL);
#endif
  {
   self->setArray(d,pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMessage of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_setMessage00
static int tolua_CsbufParser_CsbufParser_setMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMessage'", NULL);
#endif
  {
   self->setMessage(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endSetMessage of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_endSetMessage00
static int tolua_CsbufParser_CsbufParser_endSetMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endSetMessage'", NULL);
#endif
  {
   self->endSetMessage();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endSetMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBool of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getBool00
static int tolua_CsbufParser_CsbufParser_getBool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBool'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getBool(pos);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUint8 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getUint800
static int tolua_CsbufParser_CsbufParser_getUint800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUint8'", NULL);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->getUint8(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUint8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUint16 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getUint1600
static int tolua_CsbufParser_CsbufParser_getUint1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUint16'", NULL);
#endif
  {
   unsigned short tolua_ret = ( unsigned short)  self->getUint16(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUint16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUint32 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getUint3200
static int tolua_CsbufParser_CsbufParser_getUint3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUint32'", NULL);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->getUint32(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUint32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUint64 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getUint6400
static int tolua_CsbufParser_CsbufParser_getUint6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUint64'", NULL);
#endif
  {
   unsigned long long tolua_ret = ( unsigned long long)  self->getUint64(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUint64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInt8 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getInt800
static int tolua_CsbufParser_CsbufParser_getInt800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInt8'", NULL);
#endif
  {
    char tolua_ret = (  char)  self->getInt8(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInt8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInt16 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getInt1600
static int tolua_CsbufParser_CsbufParser_getInt1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInt16'", NULL);
#endif
  {
    short tolua_ret = (  short)  self->getInt16(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInt16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInt32 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getInt3200
static int tolua_CsbufParser_CsbufParser_getInt3200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInt32'", NULL);
#endif
  {
    int tolua_ret = (  int)  self->getInt32(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInt32'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInt64 of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getInt6400
static int tolua_CsbufParser_CsbufParser_getInt6400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInt64'", NULL);
#endif
  {
   long long tolua_ret = ( long long)  self->getInt64(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInt64'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloat of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getFloat00
static int tolua_CsbufParser_CsbufParser_getFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloat'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFloat(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDouble of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getDouble00
static int tolua_CsbufParser_CsbufParser_getDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDouble'", NULL);
#endif
  {
   double tolua_ret = (double)  self->getDouble(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getString of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getString00
static int tolua_CsbufParser_CsbufParser_getString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getString'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getString(pos);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getArray of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getArray00
static int tolua_CsbufParser_CsbufParser_getArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getArray'", NULL);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->getArray(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMessage of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_getMessage00
static int tolua_CsbufParser_CsbufParser_getMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
  unsigned char pos = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMessage'", NULL);
#endif
  {
   unsigned short tolua_ret = ( unsigned short)  self->getMessage(pos);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endGetMessage of class  CsbufParser */
#ifndef TOLUA_DISABLE_tolua_CsbufParser_CsbufParser_endGetMessage00
static int tolua_CsbufParser_CsbufParser_endGetMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CsbufParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CsbufParser* self = (CsbufParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endGetMessage'", NULL);
#endif
  {
   self->endGetMessage();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endGetMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_CsbufParser_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CsbufParser","CsbufParser","",tolua_collect_CsbufParser);
  #else
  tolua_cclass(tolua_S,"CsbufParser","CsbufParser","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CsbufParser");
   tolua_function(tolua_S,"new",tolua_CsbufParser_CsbufParser_new00);
   tolua_function(tolua_S,"new_local",tolua_CsbufParser_CsbufParser_new00_local);
   tolua_function(tolua_S,".call",tolua_CsbufParser_CsbufParser_new00_local);
   tolua_function(tolua_S,"new",tolua_CsbufParser_CsbufParser_new01);
   tolua_function(tolua_S,"new_local",tolua_CsbufParser_CsbufParser_new01_local);
   tolua_function(tolua_S,".call",tolua_CsbufParser_CsbufParser_new01_local);
   tolua_function(tolua_S,"delete",tolua_CsbufParser_CsbufParser_delete00);
   tolua_function(tolua_S,"setData",tolua_CsbufParser_CsbufParser_setData00);
   tolua_function(tolua_S,"setData",tolua_CsbufParser_CsbufParser_setData01);
   tolua_function(tolua_S,"setData",tolua_CsbufParser_CsbufParser_setData02);
   tolua_function(tolua_S,"getData",tolua_CsbufParser_CsbufParser_getData00);
   tolua_function(tolua_S,"clear",tolua_CsbufParser_CsbufParser_clear00);
   tolua_function(tolua_S,"setBool",tolua_CsbufParser_CsbufParser_setBool00);
   tolua_function(tolua_S,"setUint8",tolua_CsbufParser_CsbufParser_setUint800);
   tolua_function(tolua_S,"setUint16",tolua_CsbufParser_CsbufParser_setUint1600);
   tolua_function(tolua_S,"setUint32",tolua_CsbufParser_CsbufParser_setUint3200);
   tolua_function(tolua_S,"setUint64",tolua_CsbufParser_CsbufParser_setUint6400);
   tolua_function(tolua_S,"setInt8",tolua_CsbufParser_CsbufParser_setInt800);
   tolua_function(tolua_S,"setInt16",tolua_CsbufParser_CsbufParser_setInt1600);
   tolua_function(tolua_S,"setInt32",tolua_CsbufParser_CsbufParser_setInt3200);
   tolua_function(tolua_S,"setInt64",tolua_CsbufParser_CsbufParser_setInt6400);
   tolua_function(tolua_S,"setFloat",tolua_CsbufParser_CsbufParser_setFloat00);
   tolua_function(tolua_S,"setDouble",tolua_CsbufParser_CsbufParser_setDouble00);
   tolua_function(tolua_S,"setString",tolua_CsbufParser_CsbufParser_setString00);
   tolua_function(tolua_S,"setString",tolua_CsbufParser_CsbufParser_setString01);
   tolua_function(tolua_S,"setString",tolua_CsbufParser_CsbufParser_setString02);
   tolua_function(tolua_S,"setArray",tolua_CsbufParser_CsbufParser_setArray00);
   tolua_function(tolua_S,"setMessage",tolua_CsbufParser_CsbufParser_setMessage00);
   tolua_function(tolua_S,"endSetMessage",tolua_CsbufParser_CsbufParser_endSetMessage00);
   tolua_function(tolua_S,"getBool",tolua_CsbufParser_CsbufParser_getBool00);
   tolua_function(tolua_S,"getUint8",tolua_CsbufParser_CsbufParser_getUint800);
   tolua_function(tolua_S,"getUint16",tolua_CsbufParser_CsbufParser_getUint1600);
   tolua_function(tolua_S,"getUint32",tolua_CsbufParser_CsbufParser_getUint3200);
   tolua_function(tolua_S,"getUint64",tolua_CsbufParser_CsbufParser_getUint6400);
   tolua_function(tolua_S,"getInt8",tolua_CsbufParser_CsbufParser_getInt800);
   tolua_function(tolua_S,"getInt16",tolua_CsbufParser_CsbufParser_getInt1600);
   tolua_function(tolua_S,"getInt32",tolua_CsbufParser_CsbufParser_getInt3200);
   tolua_function(tolua_S,"getInt64",tolua_CsbufParser_CsbufParser_getInt6400);
   tolua_function(tolua_S,"getFloat",tolua_CsbufParser_CsbufParser_getFloat00);
   tolua_function(tolua_S,"getDouble",tolua_CsbufParser_CsbufParser_getDouble00);
   tolua_function(tolua_S,"getString",tolua_CsbufParser_CsbufParser_getString00);
   tolua_function(tolua_S,"getArray",tolua_CsbufParser_CsbufParser_getArray00);
   tolua_function(tolua_S,"getMessage",tolua_CsbufParser_CsbufParser_getMessage00);
   tolua_function(tolua_S,"endGetMessage",tolua_CsbufParser_CsbufParser_endGetMessage00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_CsbufParser (lua_State* tolua_S) {
 return tolua_CsbufParser_open(tolua_S);
};
#endif

